#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
脑状态分类服务

基于脑波相对功率比进行用户状态分类
接收BrainWaveRatesInput，返回BrainStateOutput
"""

import sys
import os
import logging
from typing import Dict, List, Optional, Tuple
from datetime import datetime

# 添加项目根目录到Python路径
current_dir = os.path.dirname(os.path.abspath(__file__))
project_root = os.path.dirname(current_dir)
sys.path.insert(0, project_root)

from models.brain_state_models import BrainWaveRatesInput, BrainStateOutput
from exception.base_exceptions import BrainStateException, ValidationException
from exception.exception_handler import global_exception_handler

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class BrainStateService:
    """
    扩展脑状态分类服务类 - 基于国际睡眠医学标准(AASM)和脑电学研究
    
    核心功能：
    1. 严格验证输入数据的完整性和合理性
    2. 基于5个脑波频段的相对功率比进行精细状态分类
    3. 支持11种状态分类，包括5种睡眠阶段和6种清醒/认知状态
    4. 采用优先级分类算法，确保医学上重要的状态优先识别
    5. 计算科学的分类置信度并返回标准化结果
    
    支持的状态分类：
    
    === 睡眠状态（基于AASM标准）===
    - N3深度睡眠：Delta波≥50%，其他频段极低（慢波睡眠，深度恢复期）
    - N2浅睡眠：Delta波20-50%，Theta波15-35%（睡眠纺锤波期）
    - N1入睡期：Theta波25-50%，Alpha波减少（浅睡眠过渡期）
    - REM快速眼动睡眠：Theta波30-60%，Beta波活跃，Delta波极低（梦境期）
    - 眼动期：Alpha波20-45%，Theta波开始增加（准备入睡）
    
    === 清醒认知状态 ===
    - 困倦状态：Theta波40-70%，Alpha波减少（疲劳警告）
    - 深度冥想：Theta波45-75%，Alpha波存在（意识清醒的深度放松）
    - 放松状态：Alpha波25-55%主导（轻度冥想，休息状态）
    - 专注状态：Beta波25-50%，Alpha波辅助（学习工作状态）
    - 兴奋状态：Beta波≥35%，Gamma波增加（高度警觉，压力状态）
    - 信号异常：极端波形，可能的设备或生理干扰
    
    科学依据：
    - 基于Rechtschaffen & Kales (R&K) 和 AASM 睡眠分期标准
    - 参考国际脑电图学会(IFCN)的脑波频段定义
    - 结合现代睡眠医学和认知神经科学研究成果
    - 优化的阈值设定，平衡准确性和实用性
    
    算法特点：
    - 实时处理能力：O(n×m×k)复杂度，适合连续监测
    - 优先级分类：医学重要状态优先识别，避免误分类
    - 容错设计：宽松的置信度计算，适应个体差异
    - 可扩展性：易于添加新状态或调整阈值
    """
    
    # 支持的脑波频段（8频域扩展）
    SUPPORTED_BANDS_8 = ['delta', 'theta', 'low_alpha', 'high_alpha', 'low_beta', 'high_beta', 'low_gamma', 'mid_gamma']
    SUPPORTED_BANDS_5 = ['delta', 'theta', 'alpha', 'beta', 'gamma']  # 向后兼容
    
    # 扩展的8频域状态分类规则 - 基于国际睡眠医学标准和脑电学研究
    # 包含细致的睡眠阶段分类和认知状态识别
    # 优化版8频段状态规则（基于OptimizedBrainStateService）
    STATE_RULES_8BAND_OPTIMIZED = {
        'alert': {
            'description': '警觉/清醒状态',
            'conditions': {
                'delta_max': 0.15,
                'theta_max': 0.20,
                'low_alpha_min': 0.12, 'low_alpha_max': 0.35,
                'high_alpha_min': 0.10, 'high_alpha_max': 0.35,
                'low_beta_min': 0.08,
                'high_beta_min': 0.06,
                'low_gamma_min': 0.02,
                'mid_gamma_min': 0.01,
            },
            'priority': 3
        },
        'relaxed': {
            'description': '放松状态',
            'conditions': {
                'delta_max': 0.25,  # 放宽Delta波上限，避免与睡眠状态冲突
                'theta_max': 0.30,   # 放宽Theta波上限
                'low_alpha_min': 0.15,
                'high_alpha_min': 0.12,
                'low_beta_max': 0.28,  # 提高Beta波上限，允许轻度活跃
                'high_beta_max': 0.22, # 提高高频Beta波上限
                'low_gamma_max': 0.10,  # 放宽Gamma波限制
                'mid_gamma_max': 0.08,
            },
            'priority': 2  # 提高优先级，与睡眠状态同级
        },
        'drowsy': {
            'description': '困倦状态',
            'conditions': {
                'delta_min': 0.18, 'delta_max': 0.30,  # 添加Delta波范围，区分困倦和清醒
                'theta_min': 0.15, 'theta_max': 0.35,  # 困倦时Theta波增加
                'low_alpha_max': 0.25,   # 收紧Alpha波上限
                'high_alpha_max': 0.20,  # 收紧高频Alpha波上限
                'low_beta_max': 0.18,    # 调整Beta波上限
                'high_beta_max': 0.12,   # 调整高频Beta波上限
                'low_gamma_max': 0.06,
                'mid_gamma_max': 0.04,
            },
            'priority': 2
        },
        'n1_light_sleep': {
            'description': 'N1浅睡眠',
            'conditions': {
                'delta_min': 0.35, 'delta_max': 0.45,  # 大幅提高Delta波最小值
                'theta_min': 0.12, 'theta_max': 0.25,  # 调整Theta波范围
                'low_alpha_min': 0.10, 'low_alpha_max': 0.20,  # 添加Alpha波范围限制
                'high_alpha_max': 0.15,  # 收紧高频Alpha波上限
                'low_beta_max': 0.08,    # 收紧Beta波上限
                'high_beta_max': 0.05,   # 收紧高频Beta波上限
                'low_gamma_max': 0.03,   # 收紧Gamma波上限
                'mid_gamma_max': 0.02,   # 收紧中频Gamma波上限
            },
            'priority': 1  # 保持最高优先级
        },
        'n2_light_sleep': {
            'description': 'N2浅睡眠',
            'conditions': {
                'delta_min': 0.40, 'delta_max': 0.60,  # 大幅提高Delta波最小值，确保真正的睡眠状态
                'theta_min': 0.08, 'theta_max': 0.20,  # 收紧Theta波范围
                'low_alpha_max': 0.15,   # 进一步收紧Alpha波上限
                'high_alpha_max': 0.10,  # 进一步收紧高频Alpha波上限
                'low_beta_max': 0.06,    # 进一步收紧Beta波上限
                'high_beta_max': 0.04,   # 进一步收紧高频Beta波上限
                'low_gamma_max': 0.02,   # 进一步收紧Gamma波上限
                'mid_gamma_max': 0.01,   # 进一步收紧中频Gamma波上限
            },
            'priority': 1  # 保持最高优先级
        },
        'n3_deep_sleep': {
            'description': 'N3深度睡眠',
            'conditions': {
                'delta_min': 0.40,
                'theta_max': 0.25,
                'low_alpha_max': 0.15,
                'high_alpha_max': 0.10,
                'low_beta_max': 0.10,
                'high_beta_max': 0.08,
                'low_gamma_max': 0.05,
                'mid_gamma_max': 0.05,
            },
            'priority': 1
        },
        'rem_sleep': {
            'description': 'REM睡眠',
            'conditions': {
                'delta_max': 0.20,
                'theta_min': 0.12,
                'low_alpha_min': 0.08, 'low_alpha_max': 0.25,
                'high_alpha_min': 0.05, 'high_alpha_max': 0.20,
                'low_beta_min': 0.08,
                'high_beta_min': 0.05,
                'low_gamma_min': 0.02,
                'mid_gamma_min': 0.01,
            },
            'priority': 1
        },
        'meditative': {
            'description': '冥想状态',
            'conditions': {
                'delta_max': 0.15,
                'theta_min': 0.25, 'theta_max': 0.60,
                'low_alpha_min': 0.15, 'low_alpha_max': 0.35,
                'high_alpha_min': 0.10, 'high_alpha_max': 0.30,
                'low_beta_max': 0.15,
                'high_beta_max': 0.10,
                'low_gamma_max': 0.06,
                'mid_gamma_max': 0.04,
            },
            'priority': 2
        },
        'artifact': {
            'description': '信号异常',
            'conditions': {
                'low_gamma_min': 0.30,
                'mid_gamma_min': 0.25,
            },
            'priority': 1
        }
    }

    # 原始8频段状态规则（保持向后兼容）
    STATE_RULES_8BAND = {
        'n3_deep_sleep': {
            'description': 'N3深度睡眠（慢波睡眠）',
            'conditions': {
                'delta_min': 0.20,         # Delta波占主导地位（AASM标准：Delta > 总功率的20%）
                'theta_max': 0.25,         # Theta波显著降低但允许更多存在
                'low_alpha_max': 0.15,     # Low Alpha波几乎消失但允许更多
                'high_alpha_max': 0.12,    # High Alpha波极低但允许更多
                'low_beta_max': 0.15,      # Low Beta波降至最低但允许更多
                'high_beta_max': 0.12,     # High Beta波最低但允许更多
                'low_gamma_max': 0.10,     # Low Gamma波最低但允许更多
                'mid_gamma_max': 0.08,     # Mid Gamma波极低但允许更多
            },
            'priority': 1  # 最高优先级，避免与其他睡眠状态混淆
        },
        'n2_light_sleep': {
            'description': 'N2浅睡眠（睡眠纺锤波期）',
            'conditions': {
                'theta_min': 0.15,         # Theta波增加（降低要求适应个体差异）
                'theta_max': 0.50,         # Theta波上限
                'delta_min': 0.25,         # Delta波开始增加（提高要求确保真正睡眠）
                'delta_max': 0.40,         # Delta波但仍低于N3水平
                'low_alpha_max': 0.15,     # Low Alpha波显著减少但允许一定存在
                'high_alpha_max': 0.12,    # High Alpha波很低但允许一定存在
                'low_beta_min': 0.02,      # Low Beta少量存在（降低最低要求）
                'low_beta_max': 0.15,      # Low Beta波上限
                'high_beta_max': 0.12,     # High Beta波很低但允许一定存在
                'low_gamma_max': 0.08,     # Low Gamma波极低但允许一定存在
                'mid_gamma_max': 0.06,     # Mid Gamma波极低但允许一定存在
            },
            'priority': 2
        },
        'n1_light_sleep': {
            'description': 'N1入睡期（浅睡眠过渡期）',
            'conditions': {
                'theta_min': 0.15,         # Theta波开始增加（医学标准：Theta功率开始增加）
                'theta_max': 0.35,         # Theta波适中，未达到N2水平
                'low_alpha_min': 0.05,     # Low Alpha波减少（医学标准：Low Alpha功率开始减少）
                'low_alpha_max': 0.15,     # Low Alpha波上限，显著降低
                'high_alpha_max': 0.08,    # High Alpha波消失（医学标准：High Alpha功率消失）
                'delta_min': 0.03,         # Delta波轻微出现
                'delta_max': 0.20,         # Delta波较低，未达到N2水平
                'low_beta_max': 0.18,      # Low Beta波降低
                'high_beta_max': 0.12,     # High Beta波显著降低
                'low_gamma_max': 0.05,     # Low Gamma波很低
                'mid_gamma_max': 0.03,     # Mid Gamma波极低
            },
            'priority': 3
        },
        'rem_sleep': {
            'description': 'REM快速眼动睡眠',
            'conditions': {
                'theta_min': 0.15,         # REM期Theta波活跃（降低要求）
                'theta_max': 0.50,         # Theta波上限
                'low_beta_min': 0.08,      # Low Beta波相对活跃（降低要求适应个体差异）
                'low_beta_max': 0.35,      # Low Beta波上限
                'high_beta_min': 0.06,     # High Beta波存在（降低要求）
                'high_beta_max': 0.30,     # High Beta波上限
                'delta_max': 0.15,         # Delta波非常低（稍微放宽）
                'low_alpha_max': 0.15,     # Low Alpha波非常低（稍微放宽）
                'high_alpha_max': 0.12,    # High Alpha波非常低（稍微放宽）
                'low_gamma_min': 0.04,     # Low Gamma波增加（降低要求）
                'mid_gamma_min': 0.02,     # Mid Gamma波增加（降低要求）
                'mid_gamma_max': 0.20,     # Mid Gamma波上限
            },
            'priority': 2
        },
        'eye_movement_stage': {
            'description': '眼动期/准备入睡',
            'conditions': {
                'low_alpha_min': 0.20,     # Low Alpha波仍然存在
                'low_alpha_max': 0.35,     # Low Alpha波占比较高
                'high_alpha_min': 0.15,    # High Alpha波存在
                'high_alpha_max': 0.25,    # High Alpha波适中
                'theta_min': 0.15,         # Theta波开始增加
                'theta_max': 0.30,         # Theta波适中
                'low_beta_min': 0.10,      # Low Beta波存在但降低
                'low_beta_max': 0.25,      # Low Beta波上限
                'high_beta_min': 0.08,     # High Beta波存在
                'high_beta_max': 0.20,     # High Beta波上限
                'delta_max': 0.15,         # Delta波很低
            },
            'priority': 3
        },
        
        # === 清醒状态分类 ===
        'drowsy': {
            'description': '困倦/半睡半醒',
            'conditions': {
                'theta_min': 0.35,         # 高Theta波特征（困倦的典型标志）
                'theta_max': 0.60,         # Theta波上限
                'low_alpha_min': 0.05,     # Low Alpha波减少但存在
                'low_alpha_max': 0.15,     # Low Alpha波上限
                'high_alpha_min': 0.03,    # High Alpha波减少
                'high_alpha_max': 0.10,    # High Alpha波上限
                'delta_min': 0.08,         # 轻微Delta波
                'delta_max': 0.25,         # Delta波上限
                'low_beta_max': 0.20,      # Low Beta波中等
                'high_beta_max': 0.15,     # High Beta波较低
            },
            'priority': 3
        },
        'meditative': {
            'description': '深度冥想/Theta状态',
            'conditions': {
                'theta_min': 0.40,         # 非常高的Theta波（冥想特征）
                'theta_max': 0.70,         # Theta波上限
                'low_alpha_min': 0.10,     # Low Alpha波存在（意识清醒）
                'low_alpha_max': 0.25,     # Low Alpha波上限
                'high_alpha_min': 0.08,    # High Alpha波存在
                'high_alpha_max': 0.20,    # High Alpha波上限
                'delta_max': 0.12,         # Delta波低（区分睡眠）
                'low_beta_max': 0.15,      # Low Beta波低（放松状态）
                'high_beta_max': 0.10,     # High Beta波很低
            },
            'priority': 2
        },
        'relaxed': {
            'description': '放松/轻度冥想',
            'conditions': {
                'low_alpha_min': 0.18,     # 降低Low Alpha波最小值要求
                'low_alpha_max': 0.45,     # 提高Low Alpha波上限
                'high_alpha_min': 0.12,    # 降低High Alpha波最小值要求
                'high_alpha_max': 0.35,    # 提高High Alpha波上限
                'theta_min': 0.08,         # 降低Theta波最小值要求
                'theta_max': 0.35,         # 提高Theta波上限
                'low_beta_max': 0.25,      # 提高Low Beta波上限
                'high_beta_max': 0.20,     # 提高High Beta波上限
                'delta_max': 0.25,         # 提高Delta波上限
                'low_gamma_max': 0.08,     # 添加Gamma波限制
                'mid_gamma_max': 0.06,     # 添加中频Gamma波限制
            },
            'priority': 2  # 提高优先级，确保放松状态能被识别
        },
        'focused': {
            'description': '清醒/专注',
            'conditions': {
                'low_beta_min': 0.15,      # Low Beta波增加（降低要求适应个体差异）
                'low_beta_max': 0.45,      # Low Beta波上限
                'high_beta_min': 0.10,     # High Beta波存在（降低要求）
                'high_beta_max': 0.40,     # High Beta波上限
                'low_alpha_min': 0.10,     # Low Alpha波存在但不主导（降低要求）
                'low_alpha_max': 0.35,     # Low Alpha波上限
                'high_alpha_min': 0.05,    # High Alpha波存在（降低要求）
                'high_alpha_max': 0.30,    # High Alpha波上限
                'theta_max': 0.25,         # Theta波较低（放宽上限）
                'delta_max': 0.15,         # Delta波低（放宽上限）
                'low_gamma_max': 0.12,     # Low Gamma波适中
                'mid_gamma_max': 0.10,     # Mid Gamma波适中
            },
            'priority': 2
        },
        'excited': {
            'description': '兴奋/高度警觉/压力',
            'conditions': {
                'high_beta_min': 0.25,     # High Beta波高（兴奋/压力特征）
                'low_beta_min': 0.20,      # Low Beta波也较高
                'low_gamma_min': 0.08,     # Low Gamma波增加（高度认知活动）
                'mid_gamma_min': 0.06,     # Mid Gamma波增加
                'mid_gamma_max': 0.20,     # Mid Gamma波上限
                'low_alpha_max': 0.25,     # Low Alpha波降低
                'high_alpha_max': 0.20,    # High Alpha波降低
                'theta_max': 0.15,         # Theta波低
                'delta_max': 0.12,         # Delta波很低
            },
            'priority': 4
        },
        
        # === 特殊状态 ===
        'artifact': {
            'description': '信号异常/伪迹',
            'conditions': {
                'low_gamma_min': 0.30,     # 极高Low Gamma波表示肌电干扰
                'mid_gamma_min': 0.25,     # 极高Mid Gamma波表示电极接触不良
            },
            'priority': 1  # 高优先级，确保伪迹能被及时识别
        },
        'unknown': {
            'description': '未知/无法分类',
            'conditions': {},  # 默认分类
            'priority': 6  # 兜底分类
        }
    }
    
    def __init__(self, expected_data_points=None, use_8_bands=True, use_optimized_rules=False):
        """
        初始化服务
        
        Args:
            expected_data_points: 期望的数据点数量，如果为None则动态适应
            use_8_bands: 是否使用8频域分析（默认True），False则使用5频域兼容模式
            use_optimized_rules: 是否使用优化版状态规则（默认False），True则使用优化版规则
        """
        self.expected_data_points = expected_data_points
        self.use_8_bands = use_8_bands
        self.use_optimized_rules = use_optimized_rules
        
        # 设置数据记录文件路径
        self.data_log_file = os.path.join(project_root, "logs", "brain_state_data_log.txt")
        
        # 确保logs目录存在
        os.makedirs(os.path.dirname(self.data_log_file), exist_ok=True)
        
        # 根据模式选择频段和规则
        if use_8_bands:
            self.supported_bands = self.SUPPORTED_BANDS_8
            if use_optimized_rules:
                self.state_rules = self.STATE_RULES_8BAND_OPTIMIZED
                logger.info(f"BrainStateService 初始化完成（8频域优化模式），期望数据点数量: {expected_data_points or '动态适应'}")
            else:
                self.state_rules = self.STATE_RULES_8BAND
                logger.info(f"BrainStateService 初始化完成（8频域标准模式），期望数据点数量: {expected_data_points or '动态适应'}")
        else:
            self.supported_bands = self.SUPPORTED_BANDS_5
            if use_optimized_rules:
                self.state_rules = self.STATE_RULES_5BAND_OPTIMIZED
                logger.info(f"BrainStateService 初始化完成（5频域优化模式），期望数据点数量: {expected_data_points or '动态适应'}")
            else:
                self.state_rules = self.STATE_RULES_5BAND
                logger.info(f"BrainStateService 初始化完成（5频域标准模式），期望数据点数量: {expected_data_points or '动态适应'}")
    
    # 优化版5状态分类规则（基于BrainStateServiceOptimized）
    STATE_RULES_5BAND_OPTIMIZED = {
        'awake': {
            'description': '清醒状态',
            'conditions': {
                'alpha_min': 0.20,     # Alpha波存在（放松清醒）
                'alpha_max': 0.60,     # Alpha波上限
                'beta_min': 0.15,      # Beta波存在（专注清醒）
                'beta_max': 0.45,      # Beta波上限
                'theta_max': 0.30,     # Theta波限制（避免困倦混淆）
                'delta_max': 0.20,     # Delta波限制（避免睡眠混淆）
            },
            'priority': 2,
            'min_confidence': 0.5
        },
        'drowsy': {
            'description': '入睡/困倦状态',
            'conditions': {
                'theta_min': 0.30,     # Theta波主要特征（困倦标志）
                'theta_max': 0.65,     # Theta波上限
                'alpha_min': 0.10,     # Alpha波仍存在（意识未完全消失）
                'alpha_max': 0.35,     # Alpha波上限
                'delta_min': 0.05,     # Delta波开始出现
                'delta_max': 0.25,     # Delta波上限（区分浅睡眠）
                'beta_max': 0.30,      # Beta波限制
            },
            'priority': 2,
            'min_confidence': 0.5
        },
        'light_sleep': {
            'description': '浅睡眠状态',
            'conditions': {
                'delta_min': 0.15,     # Delta波增加（睡眠特征）
                'delta_max': 0.50,     # Delta波上限（区分深睡眠）
                'theta_min': 0.20,     # Theta波存在
                'theta_max': 0.45,     # Theta波上限
                'alpha_max': 0.25,     # Alpha波减少
                'beta_max': 0.20,      # Beta波很低
            },
            'priority': 2,
            'min_confidence': 0.5
        },
        'deep_sleep': {
            'description': '深度睡眠状态',
            'conditions': {
                'delta_min': 0.50,     # Delta波主导（深睡眠标志）
                'theta_max': 0.20,     # Theta波很低
                'alpha_max': 0.15,     # Alpha波很低
                'beta_max': 0.10,      # Beta波极低
                'gamma_max': 0.05,     # Gamma波最低
            },
            'priority': 1,  # 高优先级，重要的恢复状态
            'min_confidence': 0.6
        },
        'rem_sleep': {
            'description': 'REM睡眠状态',
            'conditions': {
                'theta_min': 0.30,     # Theta波活跃（REM特征）
                'theta_max': 0.60,     # Theta波上限
                'beta_min': 0.15,      # Beta波相对活跃（类似清醒）
                'beta_max': 0.35,      # Beta波上限
                'delta_max': 0.15,     # Delta波很低（区分其他睡眠）
                'gamma_min': 0.05,     # Gamma波存在（梦境活动）
            },
            'priority': 2,
            'min_confidence': 0.5
        },
        'artifact': {
            'description': '信号异常',
            'conditions': {
                'gamma_min': 0.40,     # 极高Gamma波（干扰标志）
            },
            'priority': 1,  # 高优先级，确保异常能被识别
            'min_confidence': 0.6
        }
    }

    # 保留原有的5频域状态分类规则（向后兼容）
    STATE_RULES_5BAND = {
        # === 睡眠状态分类（基于AASM标准） ===
        'n3_deep_sleep': {
            'description': 'N3深度睡眠（慢波睡眠）',
            'conditions': {
                'delta_min': 0.20,     # Delta波占主导地位（AASM标准：Delta > 总功率的20%）
                'theta_max': 0.25,     # Theta波显著降低但允许更多存在
                'alpha_max': 0.20,     # Alpha波几乎消失但允许更多
                'beta_max': 0.18,      # Beta波降至最低但允许更多
                'gamma_max': 0.12,     # Gamma波最低但允许更多
            },
            'priority': 1  # 最高优先级，避免与其他睡眠状态混淆
        },
        'n2_light_sleep': {
            'description': 'N2浅睡眠（睡眠纺锤波期）',
            'conditions': {
                'theta_min': 0.25,     # Theta波增加（收紧范围，确保睡眠状态）
                'theta_max': 0.45,     # Theta波上限（收紧范围，区分清醒状态）
                'delta_min': 0.15,     # Delta波开始增加（提高下限，确保睡眠）
                'delta_max': 0.40,     # Delta波但仍低于N3水平
                'alpha_max': 0.15,     # Alpha波显著减少（降低上限）
                'beta_min': 0.02,      # Beta少量存在（降低最低要求）
                'beta_max': 0.18,      # Beta波上限
                'gamma_max': 0.10,     # Gamma波极低但允许一定存在
            },
            'priority': 2
        },
        'n1_light_sleep': {
            'description': 'N1入睡期（浅睡眠过渡期）',
            'conditions': {
                'theta_min': 0.15,     # Theta波开始增加（医学标准：Theta功率开始增加）
                'theta_max': 0.35,     # Theta波适中，未达到N2水平
                'alpha_min': 0.05,     # Alpha波减少（医学标准：Alpha功率开始减少）
                'alpha_max': 0.20,     # Alpha波上限，显著降低
                'delta_min': 0.03,     # Delta波轻微出现
                'delta_max': 0.20,     # Delta波较低，未达到N2水平
                'beta_max': 0.20,      # Beta波降低
                'gamma_max': 0.08,     # Gamma波很低
            },
            'priority': 3
        },
        'rem_sleep': {
            'description': 'REM快速眼动睡眠',
            'conditions': {
                'theta_min': 0.15,     # REM期Theta波活跃（降低要求）
                'theta_max': 0.50,     # Theta波上限
                'beta_min': 0.10,      # Beta波相对活跃（降低要求适应个体差异）
                'beta_max': 0.40,      # Beta波上限
                'delta_max': 0.15,     # Delta波非常低（稍微放宽）
                'alpha_max': 0.18,     # Alpha波非常低（稍微放宽）
                'gamma_min': 0.04,     # Gamma波增加（降低要求）
                'gamma_max': 0.25,     # Gamma波上限
            },
            'priority': 2
        },
        'eye_movement_stage': {
            'description': '眼动期/准备入睡',
            'conditions': {
                'alpha_min': 0.30,     # Alpha波仍然存在（提高阈值）
                'alpha_max': 0.50,     # Alpha波占比较高
                'theta_min': 0.20,     # Theta波开始增加（提高阈值）
                'theta_max': 0.35,     # Theta波适中
                'beta_min': 0.15,      # Beta波存在但降低（提高阈值）
                'beta_max': 0.30,      # Beta波上限（提高阈值）
                'delta_max': 0.15,     # Delta波很低
            },
            'priority': 3  # 提高优先级，因为是特定的睡眠准备阶段
        },
        
        # === 清醒状态分类 ===
        'drowsy': {
            'description': '困倦/半睡半醒',
            'conditions': {
                'theta_min': 0.45,     # 高Theta波特征（提高下限，区分N2睡眠）
                'theta_max': 0.65,     # Theta波上限（降低以区分冥想）
                'alpha_min': 0.05,     # Alpha波减少但存在
                'alpha_max': 0.15,     # Alpha波上限（降低上限，区分清醒）
                'delta_min': 0.08,     # 轻微Delta波（增加以区分冥想）
                'delta_max': 0.25,     # Delta波上限
                'beta_max': 0.20,      # Beta波中等（降低上限）
            },
            'priority': 3
        },
        'meditative': {
            'description': '深度冥想/Theta状态',
            'conditions': {
                'theta_min': 0.50,     # 非常高的Theta波（冥想特征，提高阈值）
                'theta_max': 0.75,     # Theta波上限
                'alpha_min': 0.15,     # Alpha波存在（意识清醒，提高阈值）
                'alpha_max': 0.35,     # Alpha波上限（提高以区分困倦）
                'delta_max': 0.12,     # Delta波低（区分睡眠，降低阈值）
                'beta_max': 0.20,      # Beta波低（放松状态，降低阈值）
            },
            'priority': 2  # 提高优先级，因为冥想是更积极的状态
        },
        'relaxed': {
            'description': '放松/轻度冥想',
            'conditions': {
                'alpha_min': 0.25,     # Alpha波主导（放松特征）
                'alpha_max': 0.55,     # Alpha波上限
                'theta_min': 0.10,     # Theta波存在
                'theta_max': 0.35,     # Theta波适中
                'beta_min': 0.05,      # Beta波较低
                'beta_max': 0.25,      # Beta波上限
                'delta_max': 0.20,     # Delta波较低
            },
            'priority': 4
        },
        'focused': {
            'description': '清醒/专注',
            'conditions': {
                'beta_min': 0.20,      # Beta波增加（降低要求适应个体差异）
                'beta_max': 0.55,      # Beta波上限
                'alpha_min': 0.15,     # Alpha波存在但不主导（降低要求）
                'alpha_max': 0.45,     # Alpha波上限
                'theta_max': 0.25,     # Theta波较低（放宽上限）
                'delta_max': 0.18,     # Delta波低（放宽上限）
                'gamma_max': 0.15,     # Gamma波适中
            },
            'priority': 2  # 提高优先级，专注是重要的认知状态
        },
        'excited': {
            'description': '兴奋/高度警觉/压力',
            'conditions': {
                'beta_min': 0.40,      # 高Beta波（兴奋/压力特征，提高阈值）
                'gamma_min': 0.12,     # Gamma波增加（高度认知活动，提高阈值）
                'gamma_max': 0.25,     # Gamma波上限
                'alpha_max': 0.30,     # Alpha波降低（提高阈值）
                'theta_max': 0.20,     # Theta波低（降低阈值）
                'delta_max': 0.12,     # Delta波很低（降低阈值）
            },
            'priority': 4
        },
        
        # === 特殊状态 ===
        'artifact': {
            'description': '信号异常/伪迹',
            'conditions': {
                'gamma_min': 0.40,     # 极高Gamma波表示肌电干扰或电极接触不良
            },
            'priority': 1  # 高优先级，确保伪迹能被及时识别
        },
        'unknown': {
            'description': '未知/无法分类',
            'conditions': {},  # 默认分类
            'priority': 6  # 兜底分类
        }
    }
    
    def classify_brain_state(self, input_data: BrainWaveRatesInput) -> BrainStateOutput:
        """
        执行脑状态分类的主要方法
        
        处理流程：
        1. 数据验证：检查输入数据的完整性、一致性和合理性
        2. 特征提取：计算5个脑波频段的平均相对功率比
        3. 状态分类：基于优先级和置信度进行科学分类
        4. 结果封装：返回包含状态、置信度和详细信息的标准化结果
        
        Args:
            input_data (BrainWaveRatesInput): 包含以下字段的脑波数据：
                - session_id: 会话标识符
                - start_time/end_time: 数据时间范围
                - relative_rates: 字典，包含delta/theta/alpha/beta/gamma的功率比列表
                
        Returns:
            BrainStateOutput: 分类结果，包含：
                - session_id: 会话ID
                - state: 识别的状态名称（如'n3_deep_sleep', 'focused'等）
                - confidence: 分类置信度(0.0-1.0)
                - details: 详细信息（平均功率比、数据点数、时间戳等）
                
        Raises:
            BrainStateException: 分类过程中的业务逻辑错误
            ValidationException: 输入数据验证失败
        """
        # 1. 严格验证输入数据
        validation_result = self._validate_input(input_data)
        if not validation_result['valid']:
            raise ValidationException(validation_result['error'])

        try:
            # 2. 计算平均相对功率比
            avg_ratios = self._calculate_average_ratios(input_data.relative_rates)

            # 3. 进行状态分类
            state, confidence = self._classify_state(avg_ratios)

            # 4. 构建详细信息
            details = {
                'average_ratios': avg_ratios,
                'data_points': len(next(iter(input_data.relative_rates.values()))),
                'time_span': f"{input_data.start_time} - {input_data.end_time}",
                'classification_timestamp': datetime.now().isoformat()
            }
            
            # 5. 如果使用8频段，添加合成的5频域比例
            if self.use_8_bands:
                synthesized_5bands = self._synthesize_to_5bands(avg_ratios)
                details['synthesized_5bands'] = synthesized_5bands
                details['original_8bands'] = avg_ratios

            # 6. 记录数据到文件
            self._log_classification_data(input_data.session_id, avg_ratios, state, confidence, 
                                        synthesized_5bands if self.use_8_bands else None)
            
            # 7. 返回结果
            return BrainStateOutput(
                session_id=input_data.session_id,
                state=state,
                confidence=confidence,
                details=details
            )

        except Exception as e:
            brain_state_error = BrainStateException(
                f"状态分类过程中发生错误: {str(e)}",
                session_id=input_data.session_id
            )
            global_exception_handler.handle_exception(brain_state_error)
            raise brain_state_error
    
    def _validate_input(self, input_data: BrainWaveRatesInput) -> Dict[str, any]:
        """
        严格验证输入数据
        
        Args:
            input_data: 输入数据
            
        Returns:
            Dict: 验证结果 {'valid': bool, 'error': str}
        """
        try:
            # 1. 检查基本字段
            if not input_data:
                return {'valid': False, 'error': '输入数据为空'}
            
            if not input_data.session_id or not isinstance(input_data.session_id, str):
                return {'valid': False, 'error': 'session_id 必须是非空字符串'}
            
            if not input_data.start_time or not input_data.end_time:
                return {'valid': False, 'error': '开始时间和结束时间不能为空'}
            
            # 2. 检查relative_rates结构
            if not input_data.relative_rates or not isinstance(input_data.relative_rates, dict):
                return {'valid': False, 'error': 'relative_rates 必须是字典类型'}
            
            # 3. 检查必需的脑波频段
            missing_bands = []
            for band in self.supported_bands:
                if band not in input_data.relative_rates:
                    missing_bands.append(band)
            
            if missing_bands:
                return {
                    'valid': False, 
                    'error': f'缺少必需的脑波频段: {", ".join(missing_bands)}'
                }
            
            # 4. 检查数据点数量和一致性
            data_lengths = {}
            for band, values in input_data.relative_rates.items():
                if not isinstance(values, list):
                    return {
                        'valid': False, 
                        'error': f'{band} 频段的数据必须是列表类型'
                    }
                
                if len(values) == 0:
                    return {
                        'valid': False, 
                        'error': f'{band} 频段的数据不能为空'
                    }
                
                data_lengths[band] = len(values)
            
            # 检查所有频段的数据点数量是否一致
            unique_lengths = set(data_lengths.values())
            if len(unique_lengths) > 1:
                return {
                    'valid': False, 
                    'error': f'各频段数据点数量不一致: {data_lengths}'
                }
            
            data_point_count = list(unique_lengths)[0]
            
            # 5. 检查数据点数量是否合理
            min_points = 1  # 最少1个数据点
            max_points = 300  # 最多5分钟的数据（假设1秒1个点）
            
            if self.expected_data_points:
                # 如果设置了期望数据点数量，允许一定的误差范围
                expected_min = max(1, self.expected_data_points - 2)
                expected_max = self.expected_data_points + 2
                
                if data_point_count < expected_min or data_point_count > expected_max:
                    return {
                        'valid': False, 
                        'error': f'数据点数量({data_point_count})不符合期望范围[{expected_min}, {expected_max}]'
                    }
            else:
                # 动态适应模式，只检查基本范围
                if data_point_count < min_points:
                    return {
                        'valid': False, 
                        'error': f'数据点数量过少: {data_point_count}，至少需要{min_points}个点'
                    }
                
                if data_point_count > max_points:
                    return {
                        'valid': False, 
                        'error': f'数据点数量过多: {data_point_count}，最多支持{max_points}个点'
                    }
            
            # 6. 检查数值的合理性
            for band, values in input_data.relative_rates.items():
                for i, value in enumerate(values):
                    # 检查是否为数值类型
                    if not isinstance(value, (int, float)):
                        return {
                            'valid': False, 
                            'error': f'{band} 频段第{i+1}个数据点不是数值类型: {value}'
                        }
                    
                    # 检查相对功率比是否在合理范围内 (0-1)
                    if value < 0 or value > 1:
                        return {
                            'valid': False, 
                            'error': f'{band} 频段第{i+1}个数据点超出范围[0,1]: {value}'
                        }
            
            # 7. 检查每个时间点的功率比总和是否接近1
            for i in range(data_point_count):
                total_power = sum(
                    input_data.relative_rates[band][i] 
                    for band in self.supported_bands
                )
                
                # 允许一定的误差范围（考虑浮点数精度）
                if abs(total_power - 1.0) > 0.1:
                    return {
                        'valid': False, 
                        'error': f'第{i+1}个时间点的功率比总和异常: {total_power:.3f}，应接近1.0'
                    }
            
            return {'valid': True, 'error': None}
            
        except Exception as e:
            validation_error = ValidationException(
                f"验证过程异常: {str(e)}",
                field="input_validation"
            )
            global_exception_handler.handle_exception(validation_error)
            return {'valid': False, 'error': f'验证过程异常: {str(e)}'}
    
    def _calculate_average_ratios(self, relative_rates: Dict[str, List[float]]) -> Dict[str, float]:
        """
        计算各脑波频段的平均相对功率比
        
        这是特征提取的核心步骤，将时间序列的脑波数据转换为
        用于状态分类的特征向量。使用简单算术平均以保持实时性。
        
        脑波频段定义（基于国际标准）：
        - Delta (δ): 0.5-4 Hz - 深度睡眠的主要成分
        - Theta (θ): 4-8 Hz - 困倦、冥想、REM睡眠
        - Alpha (α): 8-13 Hz - 放松清醒、闭眼休息
        - Beta (β): 13-30 Hz - 清醒专注、认知活动
        - Gamma (γ): 30-100 Hz - 高度认知、意识整合
        
        Args:
            relative_rates: 各频段的相对功率比时间序列数据
                格式: {'delta': [0.2, 0.3, ...], 'theta': [0.1, 0.2, ...], ...}
                
        Returns:
            Dict[str, float]: 各频段的平均相对功率比
                格式: {'delta': 0.25, 'theta': 0.15, 'alpha': 0.30, ...}
                所有值的总和应接近1.0
        """
        avg_ratios = {}
        
        for band in self.supported_bands:
            if band in relative_rates:
                values = relative_rates[band]
                avg_ratios[band] = sum(values) / len(values)
            else:
                avg_ratios[band] = 0.0
        
        # 计算得到的平均功率比
        return avg_ratios
    
    def _classify_state(self, avg_ratios: Dict[str, float]) -> Tuple[str, float]:
        """
        基于平均相对功率比进行脑状态分类
        
        改进算法流程：
        1. 计算所有状态的置信度
        2. 筛选出置信度达到阈值的候选状态
        3. 在候选状态中，优先选择高置信度的状态
        4. 当置信度差异不大时，考虑优先级
        
        Args:
            avg_ratios: 各频段的平均相对功率比
            
        Returns:
            Tuple[str, float]: (状态名称, 置信度)
        """
        print(f"\n### 脑状态分类调试 ###")
        print(f"输入波段比例: {avg_ratios}")
        
        candidates = []
        all_confidences = []  # 记录所有状态的置信度
        
        # 计算所有状态的置信度并筛选候选状态
        for state_name, state_info in self.state_rules.items():
            if state_name == 'unknown':
                continue
                
            confidence = self._calculate_state_confidence(avg_ratios, state_info['conditions'])
            priority = state_info.get('priority', 5)
            min_threshold = self._get_min_confidence_threshold(priority)
            
            # 记录所有状态的置信度用于调试
            all_confidences.append((state_name, confidence, min_threshold, priority))
            
            # 只考虑置信度达到阈值的状态
            if confidence >= min_threshold:
                candidates.append((state_name, confidence, priority))
        
        # 打印所有状态的置信度
        print("\n所有状态置信度计算结果:")
        for state_name, confidence, threshold, priority in sorted(all_confidences, key=lambda x: x[1], reverse=True):
            status = "✓ 候选" if confidence >= threshold else "✗ 未达标"
            print(f"{state_name:20} | 置信度: {confidence:.4f} | 阈值: {threshold:.2f} | 优先级: {priority} | {status}")
        
        if not candidates:
            print("\n没有候选状态，返回 unknown")
            return 'unknown', 0.3
        
        # 按置信度降序排序
        candidates.sort(key=lambda x: x[1], reverse=True)
        
        print(f"\n候选状态 ({len(candidates)}个):")
        for i, (state_name, confidence, priority) in enumerate(candidates):
            print(f"{i+1}. {state_name} - 置信度: {confidence:.4f}, 优先级: {priority}")
        
        # 选择最佳候选状态
        best_candidate = candidates[0]
        best_state, best_confidence, best_priority = best_candidate
        
        # 如果有多个候选状态，检查是否有置信度相近但优先级更高的状态
        for state_name, confidence, priority in candidates[1:]:
            # 如果置信度差异小于0.1且优先级更高，则选择高优先级状态
            if (best_confidence - confidence) < 0.1 and priority < best_priority:
                print(f"优先级调整: {best_state}({best_confidence:.4f}, 优先级{best_priority}) -> {state_name}({confidence:.4f}, 优先级{priority})")
                best_state = state_name
                best_confidence = confidence
                best_priority = priority
                break
        
        print(f"\n最终选择: {best_state} (置信度: {best_confidence:.4f})")
        print("#" * 30)
        
        return best_state, best_confidence
    
    def _get_min_confidence_threshold(self, priority: int) -> float:
        """
        根据优先级获取最小置信度阈值
        
        Args:
            priority: 状态优先级
            
        Returns:
            float: 最小置信度阈值
        """
        # 严格的置信度阈值，确保分类准确性
        thresholds = {
            1: 0.35,  # 睡眠状态等关键状态 - 大幅提高阈值确保准确性
            2: 0.10,  # 放松/困倦等重要状态 - 降低阈值以适应实际数据
            3: 0.15,  # 警觉等清醒状态
            4: 0.12,  # 其他状态
            5: 0.08,  # 异常状态
            6: 0.00   # unknown状态
        }
        return thresholds.get(priority, 0.20)
    
    def _calculate_state_confidence(self, avg_ratios: Dict[str, float], 
                                  conditions: Dict[str, float]) -> float:
        """
        计算状态匹配的置信度（科学评分算法）
        
        置信度计算原理：
        1. 条件评分：每个阈值条件根据实际值与期望值的匹配程度评分
        2. 宽松处理：未完全满足的条件仍有部分得分，适应个体差异
        3. 综合评估：条件满足率 × 平均条件得分 × 惩罚因子
        4. 科学校准：不同优先级状态采用不同的最小置信度要求
        
        评分机制：
        - min条件：实际值≥阈值时满分，否则按比例得分
        - max条件：实际值≤阈值时满分，超出时有惩罚但保留基础分
        - 综合置信度考虑条件满足的完整性和质量
        
        Args:
            avg_ratios: 各频段的平均相对功率比
                格式: {'delta': 0.25, 'theta': 0.15, ...}
            conditions: 状态的判定条件
                格式: {'delta_min': 0.2, 'theta_max': 0.3, ...}
                
        Returns:
            float: 置信度分数 (0.0-1.0)
                - 0.8-1.0: 高度匹配，状态特征明显
                - 0.6-0.8: 良好匹配，状态特征清晰
                - 0.4-0.6: 中等匹配，状态特征存在
                - 0.2-0.4: 弱匹配，状态特征不明显
                - 0.0-0.2: 不匹配，不符合状态特征
        """
        if not conditions:
            return 0.0
        
        satisfied_conditions = 0
        total_conditions = len(conditions)
        condition_scores = []
        condition_details = []  # 用于调试的详细信息
        
        for condition, threshold in conditions.items():
            parts = condition.split('_')
            if len(parts) != 2:
                continue
            
            band, operator = parts[0], parts[1]
            
            if band not in avg_ratios:
                continue
            
            actual_value = avg_ratios[band]
            
            if operator == 'min':
                # 最小值条件：实际值应该 >= 阈值
                if actual_value >= threshold:
                    satisfied_conditions += 1
                    # 超出阈值越多，得分越高（但有上限）
                    score = min(1.0, actual_value / threshold)
                    condition_scores.append(score)
                    condition_details.append(f"{condition}: {actual_value:.4f} >= {threshold:.4f} ✓ (得分: {score:.4f})")
                else:
                    # 未满足条件，得分为实际值与阈值的比例
                    score = actual_value / threshold if threshold > 0 else 0
                    condition_scores.append(score)
                    condition_details.append(f"{condition}: {actual_value:.4f} < {threshold:.4f} ✗ (得分: {score:.4f})")
            
            elif operator == 'max':
                # 最大值条件：实际值应该 <= 阈值
                if actual_value <= threshold:
                    satisfied_conditions += 1
                    # 修复评分算法：满足条件时给高分，越接近0得分越高
                    if threshold > 0:
                        # 使用反比例函数：越小得分越高，但满足条件时至少0.7分
                        score = max(0.7, 1.0 - (actual_value / threshold) * 0.5)
                    else:
                        score = 1.0
                    condition_scores.append(score)
                    condition_details.append(f"{condition}: {actual_value:.4f} <= {threshold:.4f} ✓ (得分: {score:.4f})")
                else:
                    # 超出阈值，得分降低但不为0（更宽松的处理）
                    excess_ratio = actual_value / threshold - 1.0
                    score = max(0.1, 1.0 - excess_ratio)  # 最低0.1分
                    condition_scores.append(score)
                    condition_details.append(f"{condition}: {actual_value:.4f} > {threshold:.4f} ✗ (得分: {score:.4f})")
        
        if not condition_scores:
            return 0.0
        
        # 严格的综合置信度计算：确保关键条件必须满足
        satisfaction_rate = satisfied_conditions / total_conditions
        average_score = sum(condition_scores) / len(condition_scores)
        
        # 检查是否有关键条件（如delta_min）严重不满足
        has_critical_failure = False
        for condition, threshold in conditions.items():
            if condition.endswith('_min'):
                band = condition.split('_')[0]
                if band in avg_ratios:
                    actual_value = avg_ratios[band]
                    # 如果实际值远低于最小要求（小于50%），视为关键失败
                    if actual_value < threshold * 0.5:
                        if hasattr(self, '_debug_mode') and self._debug_mode:
                            print(f"    关键失败: {condition} 实际值{actual_value:.4f} < 阈值{threshold:.4f}的50%({threshold*0.5:.4f})")
                        has_critical_failure = True
                        break
        
        # 如果有关键条件严重不满足，大幅降低置信度
        if has_critical_failure:
            confidence = min(0.05, satisfaction_rate * average_score * 0.1)  # 更严厉的惩罚
        elif satisfied_conditions < total_conditions:
            # 部分条件不满足时的惩罚
            base_confidence = satisfaction_rate * 0.6
            confidence = base_confidence * average_score * 0.8
        else:
            # 所有条件满足时给予更高置信度
            confidence = min(0.95, satisfaction_rate * average_score * 1.1)
        
        # 打印详细的条件评估（仅在调试时）
        if hasattr(self, '_debug_mode') and self._debug_mode:
            print(f"    条件详情: {condition_details}")
            print(f"    满足条件: {satisfied_conditions}/{total_conditions}, 平均得分: {average_score:.4f}, 最终置信度: {confidence:.4f}")
        
        return min(1.0, confidence)
    
    def _synthesize_to_5bands(self, avg_ratios_8bands: Dict[str, float]) -> Dict[str, float]:
        """
        将8频域比例合成为5频域比例
        
        Args:
            avg_ratios_8bands: 8频域平均比例字典
            
        Returns:
            Dict[str, float]: 合成后的5频域比例字典
        """
        try:
            # 合成5频域
            synthesized = {
                'delta': avg_ratios_8bands.get('delta', 0.0),
                'theta': avg_ratios_8bands.get('theta', 0.0),
                'alpha': avg_ratios_8bands.get('low_alpha', 0.0) + avg_ratios_8bands.get('high_alpha', 0.0),
                'beta': avg_ratios_8bands.get('low_beta', 0.0) + avg_ratios_8bands.get('high_beta', 0.0),
                'gamma': avg_ratios_8bands.get('low_gamma', 0.0) + avg_ratios_8bands.get('mid_gamma', 0.0)
            }
            
            # 归一化处理
            total = sum(synthesized.values())
            if total > 0:
                synthesized = {band: ratio / total for band, ratio in synthesized.items()}
            else:
                # 如果总和为0，设置默认值
                synthesized = {band: 0.2 for band in synthesized.keys()}
                
            return synthesized
            
        except Exception as e:
            logger.warning(f"8频域到5频域合成失败: {str(e)}")
            # 返回默认的5频域比例
            return {
                'delta': 0.2,
                'theta': 0.2,
                'alpha': 0.2,
                'beta': 0.2,
                'gamma': 0.2
            }
    
    def _create_error_output(self, session_id: str, error_message: str) -> BrainStateOutput:
        """
        创建错误输出
        
        Args:
            session_id: 会话ID
            error_message: 错误信息
            
        Returns:
            BrainStateOutput: 错误输出
        """
        return BrainStateOutput(
            session_id=session_id,
            state='error',
            confidence=0.0,
            details={
                'error': error_message,
                'timestamp': datetime.now().isoformat()
            }
        )
    
    def get_supported_states(self) -> Dict[str, str]:
        """
        获取当前支持的所有脑状态分类及其描述
        
        返回扩展后的11种状态分类，包括基于AASM标准的
        5种睡眠阶段和6种清醒认知状态。
        
        Returns:
            Dict[str, str]: 状态名称到中文描述的映射
                包含所有支持的状态及其医学/科学含义
        """
        return {
            state: info['description'] 
            for state, info in self.state_rules.items()
        }
    
    def get_state_rules(self) -> Dict[str, Dict]:
        """
        获取完整的状态分类规则配置
        
        返回所有状态的详细分类条件，包括：
        - 各频段的阈值条件（min/max）
        - 状态优先级设置
        - 状态描述和科学依据
        
        主要用于：
        - 算法调试和优化
        - 医学研究和验证
        - 系统配置和定制
        
        Returns:
            Dict[str, Dict]: 完整的状态规则配置
                包含conditions、priority、description等字段
        """
        return self.state_rules.copy()
    
    def _log_classification_data(self, session_id: str, avg_ratios: Dict[str, float], 
                               state: str, confidence: float, 
                               synthesized_5bands: Optional[Dict[str, float]] = None):
        """
        记录分类数据到文件
        
        Args:
            session_id: 会话ID
            avg_ratios: 平均频域比例（8频域或5频域）
            state: 识别的状态
            confidence: 置信度
            synthesized_5bands: 合成的5频域比例（仅在8频域模式下）
        """
        try:
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            # 准备要记录的频域数据
            if self.use_8_bands and synthesized_5bands:
                # 8频域模式：记录合成的5频域数据便于观察
                frequency_data = synthesized_5bands
                mode = "8频域模式(显示合成5频域)"
            else:
                # 5频域模式或无合成数据：直接记录原始数据
                frequency_data = avg_ratios
                mode = "5频域模式" if not self.use_8_bands else "8频域模式"
            
            # 格式化频域数据为易读格式
            freq_str = ", ".join([f"{band}: {ratio:.4f}" for band, ratio in frequency_data.items()])
            
            # 构建日志行
            log_line = f"[{timestamp}] 会话:{session_id} | 模式:{mode} | 状态:{state} | 置信度:{confidence:.4f} | 频域比例: {freq_str}\n"
            
            # 写入文件
            with open(self.data_log_file, 'a', encoding='utf-8') as f:
                f.write(log_line)
                
        except Exception as e:
            logger.warning(f"记录分类数据失败: {str(e)}")


# 使用示例
if __name__ == "__main__":
    # 创建服务实例
    service = BrainStateService()
    
    # 获取支持的状态和规则
    supported_states = service.get_supported_states()
    state_rules = service.get_state_rules()